{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# 项目简介\n",
    "\n",
    "> 2020.08.01更新：\n",
    "> 1. 新增使用`WaveFlow`作为声码器的`Transformer TTS`文字转语音实现\n",
    "> 2. AI Studio已支持libsndfile1，语音合成效果已可以在线验证，修改相关介绍\n",
    "> \n",
    "> 2020.08.03更新：\n",
    "> 1. 新增基于HTML、PDF、OCR解析的`Fastspeech`文字转语音实现：[Parakeet：飞桨，你是个成熟的框架了，要学会自己读论文](https://aistudio.baidu.com/aistudio/projectdetail/676162)\n",
    "\n",
    "该项目使用语音合成模型[WaveFlow](https://github.com/PaddlePaddle/Parakeet/blob/develop/examples/waveflow/train.py)作为AI Studio脚本环境的示例任务，同时提供Notebook环境作为对比，**强烈建议读者对照两个项目阅读**，便于理解。\n",
    "\n",
    "## 演示环境\n",
    "\n",
    "- [脚本任务示例：Parakeet——WaveFlow语音合成模型单卡训练](https://aistudio.baidu.com/aistudio/clusterprojectdetail/629531)\n",
    "- 本文：Notebook项目部署与脚本任务对比解读\n",
    "- ***建议读者***搭建本地环境进一步对比\n",
    "\n",
    "## 脚本项目介绍\n",
    "\n",
    "近期AI Studio版本更新之后，脚本任务运行环境最高支持到`Tesla V100*8`！\n",
    "\n",
    "![file](https://ai-studio-static-online.cdn.bcebos.com/ce5f3505e7d24b71b7e2843ae65d11831690b2eeaddf4e9e882a779783a60602)\n",
    "\n",
    "![file](https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1595260465871&di=5970cebcdda3989a4709bed37623fd2b&imgtype=0&src=http%3A%2F%2F5b0988e595225.cdn.sohucs.com%2Fimages%2F20180404%2F7bc8914d751046f596b1322442f99937.gif)\n",
    "\n",
    "\n",
    "然后再看一眼算力卡消耗标准，那些用不完的算力有去处了……\n",
    "\n",
    "\n",
    "| P40                         | V100 4卡                    | V100 8卡                    |\n",
    "| --------------------------- | --------------------------- | --------------------------- |\n",
    "| 0.5算力/小时                | 4算力/小时                  | 8算力/小时                  |\n",
    "\n",
    "![file](https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1595260293983&di=3e612d3033d8f0d39fe42062e52cf710&imgtype=0&src=http%3A%2F%2Fp2.ssl.cdn.btime.com%2Ft01a7f1216344770ebe.gif%3Fsize%3D500x375)\n",
    "\n",
    "然而，平台上目前公开的脚本任务示例不多（算力还是挺紧张的，非闲时需要排队，排了一天都没用到P40），因此，本文选择一个脚本任务开发的典型场景做为示例介绍，希望对大家有所帮助。\n",
    "\n",
    "## Parakeet模型库介绍\n",
    "\n",
    "Parakeet是Paddlepaddle近期上新的文字转语音（TTS,Text-to-Speech）工具库，使用飞桨模型库实现端到端的语音合成。如果您使用过各类XX读书或者新版Edge浏览器的朗读功能，这些都是典型的TTS场景。\n",
    "\n",
    "[Parakeet项目地址](https://github.com/PaddlePaddle/Parakeet)\n",
    "\n",
    "### WaveFlow模型\n",
    "\n",
    "本文使用的是百度最新推出的WaveFlow模型，根据官网介绍，只有5.9M参数量，比经典的WaveGlow语音合成模型小了15倍，同时语音合成效果也非常好。WaveFlow和WaveGlow都是基于流的生成模型，它和GAN都属于生成模型家族。\n",
    "\n",
    "**需要注意的是，WaveFlow是个vocoder（声码器，一种将声学参数转换成语音波形的工具）,不能直接实现文字转语音，需要与Parakeet库中的TTS模型Deep Voice 3、Transformer TTS或FastSpeech模型结合，实现文字转语音的拟声合成。**\n",
    "\n",
    "关于模型的详细介绍请参考：\n",
    "- [WaveFlow论文地址](https://arxiv.org/abs/1912.01219)\n",
    "- [WaveFlow: A Compact Flow-Based Model for Raw Audio](http://research.baidu.com/Blog/index-view?id=139)\n",
    "- [参考资料：理解基于流的生成模型](http://nooverfit.com/wp/gan%E5%92%8Cvae%E9%83%BDout%E4%BA%86%EF%BC%9F%E7%90%86%E8%A7%A3%E5%9F%BA%E4%BA%8E%E6%B5%81%E7%9A%84%E7%94%9F%E6%88%90%E6%A8%A1%E5%9E%8B%EF%BC%88flow-based%EF%BC%89-glow%EF%BC%8Crealnvp%E5%92%8Cnice/)\n",
    "- [WaveGlow: a Flow-based Generative Network for Speech Synthesis](https://github.com/NVIDIA/waveglow)\n",
    "\n",
    "### Transformer TTS文字转语音模型\n",
    "Parakeet使用PaddlePaddle动态图复现了Transformer TTS, 根据论文[Neural Speech Synthesis with Transformer Network](https://arxiv.org/abs/1809.08895)实现了基于Transformer的语音合成系统。\n",
    "\n",
    "![file](https://pic3.zhimg.com/80/v2-63288559f14feffe67b496d8a0fd8560_720w.jpg)\n",
    "\n",
    "在这篇论文中，作者把Transformer和Tacotron2融合，形成了TransformerTTS。\n",
    "> 模型的主体还是Original Transformer，只是在输入阶段和输出阶段为了配合语音数据的特性做了改变。首先是Encoder的Input阶段，先将text逐字符转化为编号，方便Embedding，然后进入Encoder PreNet，这层网络由一个Embedding layer和三层卷积层构成，转化为512维的向量后，进入Transformer Encoder。其次是Transformer的Decoder部分，分为Input和Output。Input通过一个PreNet，将80维的梅尔声谱图转化为512维向量，这里的PreNet是一个三层的全连接网络（个人认为论文中应当解释一下为什么Encoder的PreNet是用卷积设计的，而Decoder的PreNet由全连接网络就可以解决问题）；Output部分与Tacotron2的设计完全一致。\n",
    "\n",
    "Parakeet库中Transformer TTS支持两种vocoder，分别是Griffin-Lim algorithm和WaveFlow。WaveFlow属于基于深度神经网络的声码器，而Griffin-Lim是在仅已知幅度谱、不知道相位谱的条件下重建语音的算法，属于经典声码器，算法简单，高效。\n",
    "\n",
    "关于模型和声码器的详细介绍请参考：\n",
    "- [Transformer TTS论文地址](https://arxiv.org/abs/1809.08895)\n",
    "- [基于Transformer的语音合成系统](https://zhuanlan.zhihu.com/p/66931179)\n",
    "- [griffin-lim算法](https://blog.csdn.net/CSDN_71560364126/article/details/103968034)\n",
    "### 数据集\n",
    "\n",
    "本文的实验使用了LJ Speech语音数据集。这个数据集由13100句短语音组成，时长共计24小时。所有语音由同一名说话人录制，录制设备是Macbook Pro的内建麦克风。WaveFlow将所有语音信号重采样到22050kHz。\n",
    "\n",
    "# 开发基于Parakeet模型库的脚本任务\n",
    "1. Parakeet模型库文件相对较少，上传时间不会特别长\n",
    "2. 运行WaveFlow的时候会遇到非常多典型的场景，如数据集解压缩、缺失依赖安装、NLTK下载网络不通等问题，本文将一一予以解决\n",
    "3. WaveFlow有单GPU和多GPU的实现，目前只完成单卡训练任务，由于GPU资源紧张多卡训练任务尚未验证\n",
    "4. 由于脚本任务界面较为简单，通过注释不够直观，因此将详细的“踩坑”和处理过程在本文中展开"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# 第一步：下载Parakeet模型库\n",
    "\n",
    "## Notebook环境\n",
    "和PaddleDetection不同，目前Parakeet模型库目前文件还是比较少的，因此尽管在gitee上没有镜像，直接去github上拉取不需要花太长时间（一般也不会中断）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# 在Notebook和本地环境，只需要一行命令就搞定了\n",
    "!git clone https://github.com/PaddlePaddle/Parakeet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## 脚本任务环境\n",
    "但是！在脚本任务中，需要逐个文件夹创建、逐个文件上传。并且，由于脚本任务提交时，后台实际上执行的是命令行`python -u train.py`，因此`train.py`文件是不可删除的，只能修改内容。\n",
    "\n",
    "由于文件内容比较多，建议只上传必须的waveflow示例目录和parakeet安装必须的目录文件。\n",
    "\n",
    "另外可以使用`print(os.getcwd())`确认一下脚本任务代码界面的路径，是`/root/paddlejob/workspace/code`\n",
    "\n",
    "![file](https://ai-studio-static-online.cdn.bcebos.com/d231e957f77a4620b8ed8ec064da6847c54255f4fb0347019f5fac4bc36ebdc2)\n",
    "\n",
    "![file](https://ai-studio-static-online.cdn.bcebos.com/f9546b41e1ad4aaa924b36c4d42cce16988f3fb763c047f28da26d9265b3484a)\n",
    "\n",
    "![file](https://ai-studio-static-online.cdn.bcebos.com/3d98f5661b8a4b9a907a329fae44bacbf7221fd787e64b958b7fb76387c6f18d)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# 第二步：安装依赖库\n",
    "首先，查看下官方文档里的说明\n",
    "## Notebook环境\n",
    "\n",
    "### Install libsndfile1\n",
    "\n",
    "> Make sure the library `libsndfile1` is installed, e.g., on Ubuntu.\n",
    "> ```bash\n",
    "> sudo apt-get install libsndfile1\n",
    "> ```\n",
    "\n",
    "以Ubuntu操作系统为例，一定要装有`libsndfile1`这个开源声音文件格式处理库，目前AI Studio已经内置了该处理库，无需额外安装。\n",
    "\n",
    "### Install PaddlePaddle\n",
    "\n",
    "> Install PaddlePaddle\n",
    "> See [install](https://www.paddlepaddle.org.cn/install/quick) for more details. This repo requires PaddlePaddle **1.8.2** or above.\n",
    "\n",
    "**目前，Notebook环境支持到PaddlePaddle1.8.0，但经验证，在AI Studio的PaddlePaddle1.8.0环境WaveFlow可以正常训练。**\n",
    "\n",
    "### Install Parakeet\n",
    "\n",
    "> ```bash\n",
    "> git clone https://github.com/PaddlePaddle/Parakeet\n",
    "> cd Parakeet\n",
    "> pip install -e .\n",
    "> ```\n",
    "\n",
    "### Install CMUdict for nltk\n",
    "\n",
    "CMUdict from nltk is used to transform text into phonemes.\n",
    "\n",
    "> ```python\n",
    "> import nltk\n",
    "> nltk.download(\"punkt\")\n",
    "> nltk.download(\"cmudict\")\n",
    "> ```\n",
    "\n",
    "在Notebook环境都比较简单，照做就行。虽然`nltk.download()`会出现网络不通的报错，参考[nltk.download()出错解决](https://www.cnblogs.com/webRobot/p/6065831.html)处理即可。本文已下载并解压相关文件，可直接使用。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/aistudio/Parakeet\n"
     ]
    }
   ],
   "source": [
    "%cd Parakeet && pip install -e ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# !unzip ../nltk_data/tokenizers/punkt.zip -d ../nltk_data/tokenizers/\n",
    "# !unzip ../nltk_data/corpora/cmudict.zip -d ../nltk_data/corpora/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[nltk_data] Downloading package punkt to /home/aistudio/nltk_data...\n",
      "[nltk_data]   Package punkt is already up-to-date!\n",
      "[nltk_data] Downloading package cmudict to /home/aistudio/nltk_data...\n",
      "[nltk_data]   Package cmudict is already up-to-date!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import nltk\n",
    "nltk.download(\"punkt\")\n",
    "nltk.download(\"cmudict\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## 脚本任务环境\n",
    "\n",
    "在脚本任务中，Parakeet和NLTK的安装会比较麻烦\n",
    "\n",
    "### Install libsndfile1\n",
    "\n",
    "无需安装，下载输出的权重文件至本地预测即可。\n",
    "\n",
    "### Install PaddlePaddle\n",
    "\n",
    "脚本任务支持PaddlePaddle1.8.2环境，无需安装。\n",
    "\n",
    "### Install Parakeet\n",
    "\n",
    "此处需要将原`train.py`文件开头的`import`的最后两行注释掉，因为Parakeet未安装之前是无法`from parakeet.utils import io`的。\n",
    "\n",
    "同时，脚本任务环境的依赖库和Notebook环境不完全一样，另外缺失了一些依赖包。在没有命令行界面的情况下，需要使用`os.system()`执行`pip`安装过程。\n",
    "\n",
    "脚本任务环境的镜像源似乎也有点问题，因此需要额外指定国内镜像，处理代码如下：\n",
    "\n",
    "```python\n",
    "    os.system(\"pip install -i https://pypi.douban.com/simple/ --upgrade pip\")\n",
    "    os.system(\"pip install -i https://pypi.douban.com/simple/ unidecode==1.1.1\")\n",
    "    os.system(\"pip install -i https://pypi.douban.com/simple/ ruamel.yaml\")\n",
    "    os.system(\"pip install -i https://mirror.baidu.com/pypi/simple tensorboard\")\n",
    "    os.system(\"pip install -i https://mirror.baidu.com/pypi/simple -e .\")\n",
    "```\n",
    "\n",
    "在依赖安装完成后，再`import`需要的库：\n",
    "\n",
    "```python\n",
    "    import os\n",
    "    import random\n",
    "    import subprocess\n",
    "    import time\n",
    "    from pprint import pprint\n",
    "    \n",
    "    import argparse\n",
    "    import numpy as np\n",
    "    import paddle.fluid.dygraph as dg\n",
    "    from paddle import fluid\n",
    "    from tensorboardX import SummaryWriter\n",
    "    \n",
    "    import utils\n",
    "    from parakeet.utils import io\n",
    "    from waveflow import WaveFlow\n",
    "```\n",
    "\n",
    "### Install CMUdict for nltk\n",
    "\n",
    "在脚本任务中NLTK数据集也是提前上传好，只是需要移动目录到指定位置（即root目录下，`nltk.download()`在脚本任务环境的数据集默认解压目录）\n",
    "\n",
    "![file](https://ai-studio-static-online.cdn.bcebos.com/3c3e738af72343849fc51212f4dc00e39ccfb50a0d2b4184a23410a409973301)\n",
    "\n",
    "```python\n",
    "    os.system(\"mv ./nltk_data /root/\")\n",
    "    import nltk\n",
    "    nltk.download(\"punkt\")\n",
    "    nltk.download(\"cmudict\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# 第三步：准备数据集和预训练模型\n",
    "\n",
    "参考官方文档，Parakeet项目提供了WaveFlow模型64, 96和128比特率的预训练模型\n",
    "\n",
    "<div align=\"center\">\n",
    "<table>\n",
    "    <thead>\n",
    "        <tr>\n",
    "            <th  style=\"width: 250px\">\n",
    "            <a href=\"https://paddlespeech.bj.bcebos.com/Parakeet/waveflow_res64_ljspeech_ckpt_1.0.zip\">WaveFlow (res. channels 64)</a>\n",
    "            </th>\n",
    "            <th  style=\"width: 250px\">\n",
    "            <a href=\"https://paddlespeech.bj.bcebos.com/Parakeet/waveflow_res96_ljspeech_ckpt_1.0.zip\">WaveFlow (res. channels 96)</a>\n",
    "            </th>\n",
    "            <th  style=\"width: 250px\">\n",
    "            <a href=\"https://paddlespeech.bj.bcebos.com/Parakeet/waveflow_res128_ljspeech_ckpt_1.0.zip\">WaveFlow (res. channels 128)</a>\n",
    "            </th>\n",
    "        </tr>\n",
    "    </thead>\n",
    "    <tbody>\n",
    "        <tr>\n",
    "            <th>LJSpeech </th>\n",
    "            <th>LJSpeech </th>\n",
    "            <th>LJSpeech </th>\n",
    "        </tr>\n",
    "        <tr>\n",
    "            <th>\n",
    "            <audio src=\"https://paddlespeech.bj.bcebos.com/Parakeet/waveflow_res64_ljspeech_samples_1.0/step_3020k_sentence_0.wav\" controls=\"controls\">\n",
    "            </audio><br>\n",
    "            <audio src=\"https://paddlespeech.bj.bcebos.com/Parakeet/waveflow_res64_ljspeech_samples_1.0/step_3020k_sentence_1.wav\" controls=\"controls\">\n",
    "            </audio><br>\n",
    "            <audio src=\"https://paddlespeech.bj.bcebos.com/Parakeet/waveflow_res64_ljspeech_samples_1.0/step_3020k_sentence_2.wav\" controls=\"controls\">\n",
    "            </audio><br>\n",
    "            <audio src=\"https://paddlespeech.bj.bcebos.com/Parakeet/waveflow_res64_ljspeech_samples_1.0/step_3020k_sentence_3.wav\" controls=\"controls\">\n",
    "            </audio><br>\n",
    "            <audio src=\"https://paddlespeech.bj.bcebos.com/Parakeet/waveflow_res64_ljspeech_samples_1.0/step_3020k_sentence_4.wav\" controls=\"controls\">\n",
    "            </audio>\n",
    "            </th>\n",
    "            <th>\n",
    "            <audio src=\"https://paddlespeech.bj.bcebos.com/Parakeet/waveflow_res96_ljspeech_samples_1.0/step_2000k_sentence_0.wav\" controls=\"controls\">\n",
    "            </audio><br>\n",
    "            <audio src=\"https://paddlespeech.bj.bcebos.com/Parakeet/waveflow_res96_ljspeech_samples_1.0/step_2000k_sentence_1.wav\" controls=\"controls\">\n",
    "            </audio><br>\n",
    "            <audio src=\"https://paddlespeech.bj.bcebos.com/Parakeet/waveflow_res96_ljspeech_samples_1.0/step_2000k_sentence_2.wav\" controls=\"controls\">\n",
    "            </audio><br>\n",
    "            <audio src=\"https://paddlespeech.bj.bcebos.com/Parakeet/waveflow_res96_ljspeech_samples_1.0/step_2000k_sentence_3.wav\" controls=\"controls\">\n",
    "            </audio><br>\n",
    "            <audio src=\"https://paddlespeech.bj.bcebos.com/Parakeet/waveflow_res96_ljspeech_samples_1.0/step_2000k_sentence_4.wav\" controls=\"controls\">\n",
    "            </audio>\n",
    "            </th>\n",
    "            <th>\n",
    "            <audio src=\"https://paddlespeech.bj.bcebos.com/Parakeet/waveflow_res128_ljspeech_samples_1.0/step_2000k_sentence_0.wav\" controls=\"controls\">\n",
    "            </audio><br>\n",
    "            <audio src=\"https://paddlespeech.bj.bcebos.com/Parakeet/waveflow_res128_ljspeech_samples_1.0/step_2000k_sentence_1.wav\" controls=\"controls\">\n",
    "            </audio><br>\n",
    "            <audio src=\"https://paddlespeech.bj.bcebos.com/Parakeet/waveflow_res128_ljspeech_samples_1.0/step_2000k_sentence_2.wav\" controls=\"controls\">\n",
    "            </audio><br>\n",
    "            <audio src=\"https://paddlespeech.bj.bcebos.com/Parakeet/waveflow_res128_ljspeech_samples_1.0/step_2000k_sentence_3.wav\" controls=\"controls\">\n",
    "            </audio><br>\n",
    "            <audio src=\"https://paddlespeech.bj.bcebos.com/Parakeet/waveflow_res128_ljspeech_samples_1.0/step_2000k_sentence_4.wav\" controls=\"controls\">\n",
    "            </audio>\n",
    "            </th>\n",
    "        </tr>\n",
    "    </tbody>\n",
    "</table>\n",
    "</div>\n",
    "\n",
    "\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;**Note:** The input mel spectrogams are from validation dataset, which are not seen during training.\n",
    "\n",
    "## Notebook环境"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%mkdir examples/waveflow/data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "!tar xjvf /home/aistudio/data/data35036/LJSpeech.tar.bz2 -C examples/waveflow/data/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "!unzip /home/aistudio/data/data45064/waveflow_128.zip -d  examples/waveflow/\r\n",
    "# !unzip /home/aistudio/data/data45064/waveflow_64.zip -d  examples/waveflow/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## 脚本任务环境\n",
    "\n",
    "在脚本任务中，默认的数据集存放目录和Notebook环境挂载的位置不同，参考示例说明\n",
    "```python\n",
    "# 数据集文件目录\n",
    "# datasets_prefix = '/root/paddlejob/workspace/train_data/datasets/'\n",
    "```\n",
    "\n",
    "同时，由于脚本任务没有命令行界面，因此解压的时候也要用到`os.system()`，最好指定解压位置，这样后面比较好找\n",
    "\n",
    "```python\n",
    "    print('解压数据集')\n",
    "    os.system(\"tar xjvf /root/paddlejob/workspace/train_data/datasets/data35036/LJSpeech.tar.bz2 -C ./\")\n",
    "    print('解压预训练模型')\n",
    "    os.system(\"unzip /root/paddlejob/workspace/train_data/datasets/data45064/waveflow_128.zip -d /root/paddlejob/workspace/train_data/datasets/\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# 第四步：环境配置和YAML文件准备\n",
    "## Notebook环境\n",
    "1. `%set_env CUDA_VISIBLE_DEVICES=0`（Notebook环境）、`export CUDA_VISIBLE_DEVICES=0`或`os.environ['CUDA_VISIBLE_DEVICES'] = '0'`指定GPU\n",
    "2. 直接修改`Parakeet/examples/waveflow/configs/waveflow_ljspeech.yaml`文件或预训练模型的`waveflow_ljspeech.yaml`文件内容，如调整learning_rate、batch_size。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "env: CUDA_VISIBLE_DEVICES=0\n"
     ]
    }
   ],
   "source": [
    "%set_env CUDA_VISIBLE_DEVICES=0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## 脚本任务环境\n",
    "\n",
    "由于脚本任务训练时执行的命令是固定的`python -u train.py`，无法输入参数，因此要提前指定` parser.add_argument()`参数解析的默认值，同时`waveflow_ljspeech.yaml`需要**离线手动调整好直接上传**。\n",
    "> 注意：脚本任务不支持浏览和修改`.yml`和`.md`等格式文件。\n",
    "1. `train.py`\n",
    "```python\n",
    "def add_options_to_parser(parser):\n",
    "    parser.add_argument(\n",
    "        '--model',\n",
    "        type=str,\n",
    "        default='waveflow',\n",
    "        help=\"general name of the model\")\n",
    "    parser.add_argument(\n",
    "        '--name', type=str, default='waveflow', help=\"specific name of the training model\")\n",
    "    parser.add_argument(\n",
    "        '--root', type=str, default='./LJSpeech-1.1', help=\"root path of the LJSpeech dataset\")\n",
    "    # parser.add_argument(\n",
    "    #     '--config', type=str, default='/root/paddlejob/workspace/train_data/datasets/waveflow_res128_ljspeech_ckpt_1.0/waveflow_ljspeech.yaml', help=\"config path\")\n",
    "\n",
    "    parser.add_argument(\n",
    "        '--use_gpu',\n",
    "        type=utils.str2bool,\n",
    "        default=True,\n",
    "        help=\"option to use gpu training\")\n",
    "\n",
    "    parser.add_argument(\n",
    "        '--iteration',\n",
    "        type=int,\n",
    "        default=None,\n",
    "        help=(\"which iteration of checkpoint to load, \"\n",
    "              \"default to load the latest checkpoint\"))\n",
    "    parser.add_argument(\n",
    "        '--checkpoint',\n",
    "        type=str,\n",
    "        default='/root/paddlejob/workspace/train_data/datasets/waveflow_res128_ljspeech_ckpt_1.0/step-2000000',\n",
    "        help=\"path of the checkpoint to load\")\n",
    "```\n",
    "\n",
    "2. `parakeet/utils/io.py`直接指定YAML文件的位置而不是获取`--config`参数值\n",
    "```python\n",
    "def add_yaml_config_to_args(config):\n",
    "    \"\"\" Add args in yaml config to the args parsed by argparse. The argument in \n",
    "        yaml config will be overwritten by the same argument in argparse if they \n",
    "        are both valid.\n",
    "    \n",
    "    Args:\n",
    "        config (args): the args returned by `argparse.ArgumentParser().parse_args()`\n",
    "\n",
    "    Returns:\n",
    "        config: the args added yaml config.\n",
    "    \"\"\"\n",
    "    with open('./configs/waveflow_ljspeech.yaml', 'rt') as f:\n",
    "        yaml_cfg = ruamel.yaml.safe_load(f)\n",
    "    cfg_vars = vars(config)\n",
    "    for k, v in yaml_cfg.items():\n",
    "        if k in cfg_vars and cfg_vars[k] is not None:\n",
    "            continue\n",
    "        cfg_vars[k] = v\n",
    "    return config\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# 第五步：开始训练\n",
    "## Notebook环境"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/aistudio/Parakeet/examples/waveflow\n"
     ]
    }
   ],
   "source": [
    "%cd examples/waveflow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%run train.py \\\n",
    "    --config=./waveflow_res128_ljspeech_ckpt_1.0/waveflow_ljspeech.yaml \\\n",
    "    --root=./data/LJSpeech-1.1 \\\n",
    "    --name=finetune \\\n",
    "    --checkpoint=./waveflow_res128_ljspeech_ckpt_1.0/step-2000000 \\\n",
    "    --batch_size=8 \\\n",
    "    --use_gpu=true"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### 查看评估指标\n",
    "1. Train-Loss\n",
    "\n",
    "![file](https://ai-studio-static-online.cdn.bcebos.com/39503c928991410292e31be497fba4f83ed74c55ce6745e5bd35fbb0126665cd)\n",
    "2. Valid-Avg-Loss \n",
    "\n",
    "![file](https://ai-studio-static-online.cdn.bcebos.com/f30b0cd6632748dea63aef0e1215404b37ec84e0fdbb460b835780f05ec55294)\n",
    "3. Valid-1th-Flow-Log_s \n",
    "\n",
    "![file](https://ai-studio-static-online.cdn.bcebos.com/a3e39ffc00464848813f98066a4d41cadfe9143909b64692b856f398420a891a)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## 脚本任务环境\n",
    "脚本任务中，输出目录是确定的：\n",
    "```python\n",
    "# 输出文件目录. 任务完成后平台会自动把该目录所有文件压缩为tar.gz包，用户可以通过「下载输出」可以将输出信息下载到本地.\n",
    "# output_dir = \"/root/paddlejob/workspace/output\"\n",
    "```\n",
    "\n",
    "因此要注意将`train.py`中的`checkpoint directory`修改到`output_dir`中\n",
    "```python\n",
    "    # Make checkpoint directory.\n",
    "    run_dir = os.path.join(\"../output\", config.model, config.name)\n",
    "    checkpoint_dir = os.path.join(run_dir, \"checkpoint\")\n",
    "    if not os.path.exists(checkpoint_dir):\n",
    "        os.makedirs(checkpoint_dir)\n",
    "```\n",
    "![file](https://ai-studio-static-online.cdn.bcebos.com/31f70a5ed71a482c92982be25a4921116004d968bbc0486aacd38b9e0170b5f4)\n",
    "### 查看训练日志\n",
    "\n",
    "脚本任务训练状态可以在【历史任务】中查看，有时可能需要排队等待计算资源\n",
    "![file](https://ai-studio-static-online.cdn.bcebos.com/b0d83d5cb38e4167acf0a047371d7e84c4faca140a9747b2bc231b51fdc73541)\n",
    "\n",
    "开始训练后可以通过日志查看训练过程\n",
    "\n",
    "![file](https://ai-studio-static-online.cdn.bcebos.com/a6377eefa93a4209a17fef4749451bb447e74ae58d5a480aa6e008959435416e)\n",
    "\n",
    "### 完成训练\n",
    "\n",
    "脚本任务训练完成后，消息中心会收到一条通知\n",
    "\n",
    "![file](https://ai-studio-static-online.cdn.bcebos.com/603891a0a9c64f66ac388573fadcd753a823eba8fd4e4752a1f8b9e65eb224a1)\n",
    "\n",
    "如果训练输出是按照要求放在指定的 `/root/paddlejob/workspace/output`目录下，就可以直接打包下载下来。\n",
    "\n",
    "![file](https://ai-studio-static-online.cdn.bcebos.com/4efce1ac03834e6db306f092d9eb58348521f218f0ea474e9e370794f2ef6fd7)\n",
    "\n",
    "打开下载好的压缩包，就可以看到模型参数权重都在里面了\n",
    "\n",
    "![file](https://ai-studio-static-online.cdn.bcebos.com/4b5e03e40ea746248084dd82bc51bbee6ea12089061a4216804a1ffb5a917a49)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# 第六步：实现文字转语音（TTS）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## 使用Transformer TTS + WaveFlow实现文字转语音\n",
    "\n",
    "在Parakeet模型库中，Deep Voice 3、Transformer TTS或FastSpeech是TTS模型，下面演示如何使用训练好的WaveFlow模型权重作为声码器，通过Transformer TTS实现文字转语音。\n",
    "\n",
    "Transformer TTS的训练过程与WaveFlow非常类似，本文直接使用Parakeet项目中提供的预训练模型演示效果，使用时需要同时配置Transformer TTS和WaveFlow的预训练模型权重。\n",
    "\n",
    "在Transformer TTS的示例中，最终会将下面这段文字转为语音：\n",
    "\n",
    "> Life was like a box of chocolates, you never know what you're gonna get.\n",
    "\n",
    "也可以修改`Parakeet/examples/transformer_tts/synthesis.py`文件中`synthesis()`方法的输入，合成我们想要的其它英文，比如`Hello world!`\n",
    "\n",
    "```python\n",
    "if __name__ == '__main__':\n",
    "    parser = argparse.ArgumentParser(description=\"Synthesis model\")\n",
    "    add_config_options_to_parser(parser)\n",
    "    args = parser.parse_args()\n",
    "    # Print the whole config setting.\n",
    "    pprint(vars(args))\n",
    "    synthesis(\n",
    "        \"Hello world!\",\n",
    "        args)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/aistudio/Parakeet/examples/transformer_tts\n"
     ]
    }
   ],
   "source": [
    "# 切换到TransformerTTS示例\n",
    "%cd /home/aistudio/Parakeet/examples/transformer_tts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# 下载Transformer TTS预训练模型\n",
    "!wget https://paddlespeech.bj.bcebos.com/Parakeet/transformer_tts_ljspeech_ckpt_1.0.zip"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "!unzip transformer_tts_ljspeech_ckpt_1.0.zip -d transformer_tts_ljspeech_ckpt_1.0/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'checkpoint_transformer': './transformer_tts_ljspeech_ckpt_1.0/step-120000',\n",
      " 'checkpoint_vocoder': '../waveflow/runs/waveflow/finetune/checkpoint/step-2010000',\n",
      " 'config': 'transformer_tts_ljspeech_ckpt_1.0/ljspeech.yaml',\n",
      " 'config_vocoder': '../waveflow/waveflow_res128_ljspeech_ckpt_1.0/waveflow_ljspeech.yaml',\n",
      " 'max_len': 1000,\n",
      " 'output': './synthesis',\n",
      " 'stop_threshold': 0.5,\n",
      " 'use_gpu': 1,\n",
      " 'vocoder': 'waveflow'}\n",
      "[checkpoint] Rank 0: loaded model from ./transformer_tts_ljspeech_ckpt_1.0/step-120000.pdparams\n",
      "[checkpoint] Rank 0: loaded model from ../waveflow/runs/waveflow/finetune/checkpoint/step-2010000.pdparams\n",
      "Synthesis completed !!!\n"
     ]
    }
   ],
   "source": [
    "%run synthesis.py \\\n",
    "    --use_gpu=1 \\\n",
    "    --output='./synthesis' \\\n",
    "    --config='transformer_tts_ljspeech_ckpt_1.0/ljspeech.yaml' \\\n",
    "    --checkpoint_transformer='./transformer_tts_ljspeech_ckpt_1.0/step-120000' \\\n",
    "    --vocoder='waveflow' \\\n",
    "    --config_vocoder='../waveflow/waveflow_res128_ljspeech_ckpt_1.0/waveflow_ljspeech.yaml' \\\n",
    "    --checkpoint_vocoder='../waveflow/runs/waveflow/finetune/checkpoint/step-2010000'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "                <audio controls=\"controls\" >\n",
       "                    <source src=\"data:audio/x-wav;base64,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\" type=\"audio/x-wav\" />\n",
       "                    Your browser does not support the audio element.\n",
       "                </audio>\n",
       "              "
      ],
      "text/plain": [
       "<IPython.lib.display.Audio object>"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import IPython\n",
    "IPython.display.Audio('./synthesis/samples/waveflow.wav')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# 总结：使用脚本任务环境时，需要注意什么？\n",
    "\n",
    "耐心！脚本任务运行的时候，输出并不像Notebook项目特别直观，因此一个脚本任务要顺利运行往往要经过不少波折，失败——提交——失败——提交，多关注日志输出是一个比较好的办法。\n",
    "\n",
    "```python\n",
    "# 日志记录. 任务会自动记录环境初始化日志、任务执行日志、错误日志、执行脚本中所有标准输出和标准出错流(例如print()),用户可以在「提交」任务后,通过「查看日志」追踪日志信息.\n",
    "```\n",
    "![file](https://ai-studio-static-online.cdn.bcebos.com/c633670d406e4fb0a0ce97d856bc74ff89a60637ff1d4588b10aec600c706e66)\n",
    "\n",
    "后续更新计划：\n",
    "- [Parakeet：飞桨，你是个成熟的框架了，要学会自己读论文](https://aistudio.baidu.com/aistudio/projectdetail/676162)\n",
    "- 使用语音合成模型WaveFlow在AI Studio脚本任务环境多卡训练\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "PaddlePaddle 1.8.0 (Python 3.5)",
   "language": "python",
   "name": "py35-paddle1.2.0"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
